/**
 * API React Hooks模块
 * 提供与React Query集成的API调用hooks
 * 这个模块封装了所有API调用，提供React组件中使用的hooks
 * 包括数据查询、变更操作、错误处理等功能
 */

// 导入React Query相关hooks
// useQuery用于数据查询，提供缓存、重试、后台更新等功能
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
// 导入toast通知组件，用于显示操作结果
import { toast } from 'sonner';

/**
 * 通用查询Hook
 * 封装了useQuery，提供统一的API查询功能，包括错误处理、缓存配置等
 * @param {string|Array} queryKey - 查询键，用于缓存标识，可以是字符串或数组
 * @param {Function} queryFn - 查询函数，返回Promise的异步函数
 * @param {object} options - 查询选项配置
 * @param {boolean} options.enabled - 是否启用查询，默认true
 * @param {number} options.staleTime - 数据新鲜时间，默认5分钟
 * @param {number} options.cacheTime - 缓存时间，默认10分钟
 * @param {number} options.retry - 重试次数，默认3次
 * @param {Function} options.onError - 自定义错误处理函数
 * @returns {object} 查询结果对象，包含data、isLoading、error等属性
 */
export function useApiQuery(queryKey, queryFn, options = {}) {
  // 使用解构赋值获取选项参数，并设置默认值
  const {
    enabled = true,                    // 默认启用查询
    staleTime = 5 * 60 * 1000,        // 默认数据新鲜时间：5分钟
    cacheTime = 10 * 60 * 1000,       // 默认缓存时间：10分钟
    retry = 3,                        // 默认重试次数：3次
    onError,                          // 自定义错误处理函数
    ...otherOptions                   // 其他React Query选项
  } = options;

  // 调用React Query的useQuery hook
  return useQuery({
    // 确保queryKey是数组格式，便于组合键的使用
    queryKey: Array.isArray(queryKey) ? queryKey : [queryKey],
    
    // 查询函数
    queryFn,
    
    // 是否启用查询
    enabled,
    
    // 数据新鲜时间：在此时间内，数据被认为是新鲜的，不会重新请求
    staleTime,
    
    // 缓存时间：在此时间内，数据会保留在缓存中
    cacheTime,
    
    // 失败重试次数
    retry,
    
    // 错误处理回调函数
    onError: (error) => {
      // 在控制台输出错误信息，便于调试
      console.error('API查询错误:', error);
      
      // 如果有自定义错误处理函数，则调用它
      if (onError) {
        onError(error);
      } else {
        // 否则显示默认的错误提示
        toast.error(error.message || '数据加载失败');
      }
    },
    
    // 展开其他选项
    ...otherOptions,
  });
}

/**
 * 通用变更Hook
 * 封装了useMutation，提供统一的API变更功能，包括成功/失败处理、缓存失效等
 * @param {Function} mutationFn - 变更函数，接收参数并返回Promise
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 成功回调函数
 * @param {Function} options.onError - 错误回调函数
 * @param {boolean} options.showSuccessToast - 是否显示成功提示，默认true
 * @param {boolean} options.showErrorToast - 是否显示错误提示，默认true
 * @returns {object} 变更结果对象，包含mutate、isPending、error等属性
 */
export function useApiMutation(mutationFn, options = {}) {
  // 使用解构赋值获取选项参数，并设置默认值
  const {
    onSuccess,              // 成功回调函数
    onError,                // 错误回调函数
    showSuccessToast = true, // 默认显示成功提示
    showErrorToast = true,   // 默认显示错误提示
    ...otherOptions          // 其他React Query选项
  } = options;

  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();

  // 调用React Query的useMutation hook
  return useMutation({
    // 变更函数
    mutationFn,
    
    // 成功处理回调
    onSuccess: (data, variables, context) => {
      // 如果有自定义成功处理函数，则调用它
      if (onSuccess) {
        onSuccess(data, variables, context);
      } else if (showSuccessToast) {
        // 否则显示默认的成功提示
        toast.success('操作成功');
      }
    },
    
    // 错误处理回调
    onError: (error, variables, context) => {
      // 在控制台输出错误信息，便于调试
      console.error('API变更错误:', error);
      
      // 如果有自定义错误处理函数，则调用它
      if (onError) {
        onError(error, variables, context);
      } else if (showErrorToast) {
        // 否则显示默认的错误提示
        toast.error(error.message || '操作失败');
      }
    },
    
    // 展开其他选项
    ...otherOptions,
  });
}

/**
 * 项目相关Hooks
 * 提供项目数据操作的React hooks
 */

// 导入项目服务
import { projectService } from '../services/project-service.js';
// 导入HTML代码服务
import { htmlCodeService } from '../services/html-code-service.js';

/**
 * 获取项目列表Hook
 * 使用React Query缓存项目列表数据，支持分页、搜索、筛选等功能
 * @param {object} params - 查询参数对象
 * @param {number} params.page - 页码，默认1
 * @param {number} params.pageSize - 每页数量，默认10
 * @param {string} params.search - 搜索关键词
 * @param {string} params.status - 项目状态筛选
 * @param {string} params.type - 项目类型筛选
 * @param {object} options - 查询选项配置
 * @returns {object} 查询结果，包含data、isLoading、error等属性
 */
export function useProjects(params = {}, options = {}) {
  // 使用useApiQuery hook进行数据查询
  return useApiQuery(
    // 查询键：包含'projects'、'list'和查询参数，确保不同参数有独立的缓存
    ['projects', 'list', params],
    
    // 查询函数：调用项目服务的getProjects方法
    () => projectService.getProjects(params),
    
    // 查询选项
    options
  );
}

/**
 * 获取项目详情Hook
 * 根据项目ID获取单个项目的详细信息
 * @param {string|number} id - 项目的唯一标识符
 * @param {object} options - 查询选项配置
 * @returns {object} 查询结果，包含项目详情数据
 */
export function useProject(id, options = {}) {
  // 使用useApiQuery hook进行数据查询
  return useApiQuery(
    // 查询键：包含'projects'、'detail'和项目ID
    ['projects', 'detail', id],
    
    // 查询函数：调用项目服务的getProject方法
    () => projectService.getProject(id),
    
    // 查询选项：只有当id存在时才启用查询
    {
      enabled: !!id,  // 使用双重否定转换为布尔值，确保id不为null/undefined
      ...options,     // 展开其他选项
    }
  );
}

/**
 * 创建项目Hook
 * 提供创建新项目的变更操作，成功后会自动刷新项目列表缓存
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useCreateProject(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：调用项目服务的createProject方法
    (data) => projectService.createProject(data),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: () => {
        // 使项目相关的查询缓存失效，触发重新获取
        queryClient.invalidateQueries(['projects']);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

/**
 * 更新项目Hook
 * 提供更新项目信息的变更操作，成功后会自动刷新相关缓存
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useUpdateProject(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：接收{id, data}参数，调用项目服务的updateProject方法
    ({ id, data }) => projectService.updateProject(id, data),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: (data, { id }) => {
        // 使项目列表缓存失效
        queryClient.invalidateQueries(['projects']);
        
        // 使特定项目详情缓存失效
        queryClient.invalidateQueries(['projects', 'detail', id]);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

// 删除项目
export function useDeleteProject(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    (id) => projectService.deleteProject(id),
    {
      onSuccess: () => {
        queryClient.invalidateQueries(['projects']);
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      ...options,
    }
  );
}

/**
 * 商品相关Hooks
 */

// 获取商品列表
export function useProducts(params = {}, options = {}) {
  return useApiQuery(
    ['products', 'list', params],
    () => productService.getProducts(params),
    options
  );
}

// 获取商品详情
export function useProduct(id, options = {}) {
  return useApiQuery(
    ['products', 'detail', id],
    () => productService.getProduct(id),
    {
      enabled: !!id,
      ...options,
    }
  );
}

// 创建商品
export function useCreateProduct(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    (data) => productService.createProduct(data),
    {
      onSuccess: () => {
        queryClient.invalidateQueries(['products']);
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      ...options,
    }
  );
}

// 更新商品
export function useUpdateProduct(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    ({ id, data }) => productService.updateProduct(id, data),
    {
      onSuccess: (data, { id }) => {
        queryClient.invalidateQueries(['products']);
        queryClient.invalidateQueries(['products', 'detail', id]);
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      ...options,
    }
  );
}

// 删除商品
export function useDeleteProduct(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    (id) => productService.deleteProduct(id),
    {
      onSuccess: () => {
        queryClient.invalidateQueries(['products']);
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      ...options,
    }
  );
}

/**
 * 任务相关Hooks
 */

// 获取任务列表
export function useTasks(params = {}, options = {}) {
  return useApiQuery(
    ['tasks', 'list', params],
    () => taskService.getTasks(params),
    options
  );
}

// 获取任务详情
export function useTask(id, options = {}) {
  return useApiQuery(
    ['tasks', 'detail', id],
    () => taskService.getTask(id),
    {
      enabled: !!id,
      ...options,
    }
  );
}

// 创建任务
export function useCreateTask(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    (data) => taskService.createTask(data),
    {
      onSuccess: () => {
        queryClient.invalidateQueries(['tasks']);
        queryClient.invalidateQueries(['projects']);
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      ...options,
    }
  );
}

// 更新任务
export function useUpdateTask(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    ({ id, data }) => taskService.updateTask(id, data),
    {
      onSuccess: (data, { id }) => {
        queryClient.invalidateQueries(['tasks']);
        queryClient.invalidateQueries(['tasks', 'detail', id]);
        queryClient.invalidateQueries(['projects']);
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      ...options,
    }
  );
}

// 删除任务
export function useDeleteTask(options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    (id) => taskService.deleteTask(id),
    {
      onSuccess: () => {
        queryClient.invalidateQueries(['tasks']);
        queryClient.invalidateQueries(['projects']);
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      ...options,
    }
  );
}

/**
 * 通用工具Hooks
 */

// 文件上传Hook
export function useFileUpload(options = {}) {
  return useApiMutation(
    ({ endpoint, files }) => apiClient.uploadFile(endpoint, files),
    {
      onSuccess: (data) => {
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      ...options,
    }
  );
}

// 批量操作Hook
export function useBatchOperation(operationFn, options = {}) {
  const queryClient = useQueryClient();
  
  return useApiMutation(
    operationFn,
    {
      onSuccess: (data, variables) => {
        // 根据操作类型失效相关查询
        if (variables.type === 'projects') {
          queryClient.invalidateQueries(['projects']);
        } else if (variables.type === 'products') {
          queryClient.invalidateQueries(['products']);
        } else if (variables.type === 'tasks') {
          queryClient.invalidateQueries(['tasks']);
          queryClient.invalidateQueries(['projects']);
        }
        
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      ...options,
    }
  );
}

// 搜索Hook
export function useSearch(searchFn, query, options = {}) {
  return useApiQuery(
    ['search', query],
    () => searchFn(query),
    {
      enabled: !!query && query.length > 0,
      ...options,
    }
  );
}

// 统计Hook
export function useStats(statsFn, params = {}, options = {}) {
  return useApiQuery(
    ['stats', params],
    () => statsFn(params),
    {
      staleTime: 2 * 60 * 1000, // 统计数据缓存2分钟
      ...options,
    }
  );
}

/**
 * HTML代码管理相关Hooks
 * 提供HTML代码数据操作的React hooks
 */

/**
 * 获取HTML代码列表Hook
 * 使用React Query缓存HTML代码列表数据，支持分页、搜索、筛选等功能
 * @param {object} params - 查询参数对象
 * @param {number} params.page - 页码，默认1
 * @param {number} params.pageSize - 每页数量，默认10
 * @param {string} params.search - 搜索关键词
 * @param {string} params.workspaceId - 工作空间ID筛选
 * @param {string} params.appId - 应用ID筛选
 * @param {object} options - 查询选项配置
 * @returns {object} 查询结果，包含data、isLoading、error等属性
 */
export function useHtmlCodes(params = {}, options = {}) {
  // 使用useApiQuery hook进行数据查询
  return useApiQuery(
    // 查询键：包含'html-codes'、'list'和查询参数，确保不同参数有独立的缓存
    ['html-codes', 'list', params],
    
    // 查询函数：调用HTML代码服务的getHtmlCodes方法
    () => htmlCodeService.getHtmlCodes(params),
    
    // 查询选项
    options
  );
}

/**
 * 获取HTML代码详情Hook
 * 根据ID获取单个HTML代码的详细信息
 * @param {string|number} id - HTML代码的唯一标识符
 * @param {object} options - 查询选项配置
 * @returns {object} 查询结果，包含HTML代码详情数据
 */
export function useHtmlCode(id, options = {}) {
  // 使用useApiQuery hook进行数据查询
  return useApiQuery(
    // 查询键：包含'html-codes'、'detail'和HTML代码ID
    ['html-codes', 'detail', id],
    
    // 查询函数：调用HTML代码服务的getHtmlCode方法
    () => htmlCodeService.getHtmlCode(id),
    
    // 查询选项：只有当id存在时才启用查询
    {
      enabled: !!id,  // 使用双重否定转换为布尔值，确保id不为null/undefined
      ...options,     // 展开其他选项
    }
  );
}

/**
 * 创建HTML代码Hook
 * 提供创建新HTML代码的变更操作，成功后会自动刷新HTML代码列表缓存
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useCreateHtmlCode(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：调用HTML代码服务的createHtmlCode方法
    (data) => htmlCodeService.createHtmlCode(data),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: () => {
        // 使HTML代码相关的查询缓存失效，触发重新获取
        queryClient.invalidateQueries(['html-codes']);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess();
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

/**
 * 更新HTML代码Hook
 * 提供更新HTML代码信息的变更操作，成功后会自动刷新相关缓存
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useUpdateHtmlCode(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：接收{id, data}参数，调用HTML代码服务的updateHtmlCode方法
    ({ id, data }) => htmlCodeService.updateHtmlCode(id, data),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: (data, { id }) => {
        // 使HTML代码列表缓存失效
        queryClient.invalidateQueries(['html-codes']);
        
        // 使特定HTML代码详情缓存失效
        queryClient.invalidateQueries(['html-codes', 'detail', id]);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

/**
 * 更新HTML代码内容Hook
 * 专门用于更新HTML代码的page字段（CLOB内容）
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useUpdateHtmlContent(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：接收{id, htmlContent}参数，调用HTML代码服务的updateHtmlContent方法
    ({ id, htmlContent }) => htmlCodeService.updateHtmlContent(id, htmlContent),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: (data, { id }) => {
        // 使HTML代码列表缓存失效
        queryClient.invalidateQueries(['html-codes']);
        
        // 使特定HTML代码详情缓存失效
        queryClient.invalidateQueries(['html-codes', 'detail', id]);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess(data);
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

/**
 * 删除HTML代码Hook
 * 提供删除HTML代码的变更操作，成功后会自动刷新HTML代码列表缓存
 * @param {object} options - 变更选项配置
 * @param {Function} options.onSuccess - 自定义成功回调函数
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useDeleteHtmlCode(options = {}) {
  // 获取查询客户端实例，用于缓存管理
  const queryClient = useQueryClient();
  
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：接收id参数，调用HTML代码服务的deleteHtmlCode方法
    (id) => htmlCodeService.deleteHtmlCode(id),
    
    // 变更选项配置
    {
      // 成功处理回调
      onSuccess: (data, id) => {
        // 使HTML代码相关的查询缓存失效，触发重新获取
        queryClient.invalidateQueries(['html-codes']);
        
        // 如果有自定义成功回调，则调用它
        if (options.onSuccess) {
          options.onSuccess(data, id);
        }
      },
      
      // 展开其他选项
      ...options,
    }
  );
}

/**
 * 验证HTML代码Hook
 * 提供验证HTML代码语法的变更操作
 * @param {object} options - 变更选项配置
 * @returns {object} 变更结果对象，包含mutate、isPending等属性
 */
export function useValidateHtmlCode(options = {}) {
  // 使用useApiMutation hook进行变更操作
  return useApiMutation(
    // 变更函数：接收htmlContent参数，调用HTML代码服务的validateHtmlCode方法
    (htmlContent) => htmlCodeService.validateHtmlCode(htmlContent),
    
    // 变更选项配置
    {
      // 展开其他选项
      ...options,
    }
  );
}

// 导出所有hooks的默认对象
// 这样其他模块可以一次性导入所有需要的hooks
export default {
  // 基础hooks - 通用的查询和变更hooks
  useApiQuery,      // 通用查询hook
  useApiMutation,   // 通用变更hook
  
  // 项目hooks - 项目相关的数据操作hooks
  useProjects,      // 获取项目列表
  useProject,       // 获取项目详情
  useCreateProject, // 创建项目
  useUpdateProject, // 更新项目
  useDeleteProject, // 删除项目
  
  // 商品hooks - 商品相关的数据操作hooks
  useProducts,      // 获取商品列表
  useProduct,       // 获取商品详情
  useCreateProduct, // 创建商品
  useUpdateProduct, // 更新商品
  useDeleteProduct, // 删除商品
  
  // 任务hooks - 任务相关的数据操作hooks
  useTasks,         // 获取任务列表
  useTask,          // 获取任务详情
  useCreateTask,    // 创建任务
  useUpdateTask,    // 更新任务
  useDeleteTask,    // 删除任务
  
  // HTML代码hooks - HTML代码相关的数据操作hooks
  useHtmlCodes,     // 获取HTML代码列表
  useHtmlCode,      // 获取HTML代码详情
  useCreateHtmlCode, // 创建HTML代码
  useUpdateHtmlCode, // 更新HTML代码
  useUpdateHtmlContent, // 更新HTML代码内容
  useDeleteHtmlCode, // 删除HTML代码
  useValidateHtmlCode, // 验证HTML代码
  
  // 工具hooks - 辅助功能的hooks
  useFileUpload,    // 文件上传hook
  useBatchOperation, // 批量操作hook
  useSearch,        // 搜索hook
  useStats,         // 统计hook
};
